home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / C Internet Config / IC Libraries ƒ / IC Call Glue ƒ / IC Call Glue.c
Encoding:
Text File  |  1995-11-18  |  26.2 KB  |  953 lines  |  [TEXT/SPM ]
  1. pascal ICError ICCGetConfigName(internetConfigurationComponent inst, Boolean longname,StringPtr name){
  2. #pragma options align=mac68k
  3.     struct GlueParms {
  4.         StringPtr name;
  5.         Boolean longname;
  6.         char filler;
  7.     };
  8.     
  9.     typedef struct GlueParms GlueParms;
  10.     
  11.     struct ICCallGlue {
  12.         PPC_Glue(GlueParms);
  13.     };
  14.     
  15.     typedef struct ICCallGlue ICCallGlue;
  16. #pragma options align=reset
  17.     
  18.     ICCallGlue glue;
  19.     
  20.     SetupGlue(glue,kICCGetConfigName,GlueParms,inst);
  21.     
  22.     SetGlueParm(glue,name,((StringPtr)name));
  23.     SetGlueParm(glue,longname,longname);
  24.     SetGlueParm(glue,filler,0);
  25.     
  26.     return CallComponentGlue(&glue);
  27. }
  28.  
  29. /*
  30.     
  31.     PPC glue to call the component with the correct selector.
  32. */
  33. pascal ICError ICCGetConfigReference(internetConfigurationComponent inst, ICConfigRefHandle ref){
  34. #pragma options align=mac68k
  35.     struct GlueParms {
  36.         ICConfigRefHandle ref;
  37.     };
  38.     
  39.     typedef struct GlueParms GlueParms;
  40.     
  41.     struct ICCallGlue {
  42.         PPC_Glue(GlueParms);
  43.     };
  44.     
  45.     typedef struct ICCallGlue ICCallGlue;
  46. #pragma options align=reset
  47.     
  48.     ICCallGlue glue;
  49.     
  50.     SetupGlue(glue,kICCGetConfigReference,GlueParms,inst);
  51.     
  52.     SetGlueParm(glue,ref,ref);
  53.     
  54.     return CallComponentGlue(&glue);
  55. }
  56.  
  57. /*
  58.     
  59.     PPC glue to call the component with the correct selector.
  60. */
  61. pascal ICError ICCSetConfigReference(internetConfigurationComponent inst, ICConfigRefHandle ref, long flags){
  62. #pragma options align=mac68k
  63.     struct GlueParms {
  64.         long flags;
  65.         ICConfigRefHandle ref;
  66.     };
  67.     
  68.     typedef struct GlueParms GlueParms;
  69.     
  70.     struct ICCallGlue {
  71.         PPC_Glue(GlueParms);
  72.     };
  73.     
  74.     typedef struct ICCallGlue ICCallGlue;
  75. #pragma options align=reset
  76.     
  77.     ICCallGlue glue;
  78.     
  79.     SetupGlue(glue,kICCSetConfigReference,GlueParms,inst);
  80.     
  81.     SetGlueParm(glue,flags,flags);
  82.     SetGlueParm(glue,ref,ref);
  83.     
  84.     return CallComponentGlue(&glue);
  85. }
  86.  
  87. /*
  88.     
  89.     PPC glue to call the component with the correct selector.
  90. */
  91. pascal ICError ICCSpecifyConfigFile(internetConfigurationComponent inst, FSSpec *config){
  92. #pragma options align=mac68k
  93.     struct GlueParms {
  94.         FSSpec* config;
  95.     };
  96.     
  97.     typedef struct GlueParms GlueParms;
  98.     
  99.     struct ICCallGlue {
  100.         PPC_Glue(GlueParms);
  101.     };
  102.     
  103.     typedef struct ICCallGlue ICCallGlue;
  104. #pragma options align=reset
  105.     
  106.     ICCallGlue glue;
  107.     
  108.     SetupGlue(glue,kICCSpecifyConfigFile,GlueParms,inst);
  109.     
  110.     SetGlueParm(glue,config,config);
  111.     
  112.     return CallComponentGlue(&glue);
  113. }
  114.  
  115. /*
  116.     
  117.     PPC glue to call the component with the correct selector.
  118. */
  119. pascal ICError ICCGetSeed(internetConfigurationComponent inst, long *seed){
  120. #pragma options align=mac68k
  121.     struct GlueParms {
  122.         long* seed;
  123.     };
  124.     
  125.     typedef struct GlueParms GlueParms;
  126.     
  127.     struct ICCallGlue {
  128.         PPC_Glue(GlueParms);
  129.     };
  130.     
  131.     typedef struct ICCallGlue ICCallGlue;
  132. #pragma options align=reset
  133.     
  134.     ICCallGlue glue;
  135.     
  136.     SetupGlue(glue,kICCGetSeed,GlueParms,inst);
  137.     
  138.     SetGlueParm(glue,seed,seed);
  139.     
  140.     return CallComponentGlue(&glue);
  141. }
  142.  
  143. /*
  144.     
  145.     PPC glue to call the component with the correct selector.
  146. */
  147. pascal ICError ICCGetPerm(internetConfigurationComponent inst, ICPerm *perm){
  148. #pragma options align=mac68k
  149.     struct GlueParms {
  150.         ICPerm* perm;
  151.     };
  152.     
  153.     typedef struct GlueParms GlueParms;
  154.     
  155.     struct ICCallGlue {
  156.         PPC_Glue(GlueParms);
  157.     };
  158.     
  159.     typedef struct ICCallGlue ICCallGlue;
  160. #pragma options align=reset
  161.     
  162.     ICCallGlue glue;
  163.     
  164.     SetupGlue(glue,kICCGetPerm,GlueParms,inst);
  165.     
  166.     SetGlueParm(glue,perm,perm);
  167.     
  168.     return CallComponentGlue(&glue);
  169.     
  170. }
  171.  
  172. /*
  173.     
  174.     PPC glue to call the component with the correct selector.
  175. */
  176. pascal ICError ICCBegin(internetConfigurationComponent inst, ICPerm perm){
  177. #pragma options align=mac68k
  178.     struct GlueParms {
  179.         ICPerm perm;
  180.         char filler0;
  181.     };
  182.     
  183.     typedef struct GlueParms GlueParms;
  184.     
  185.     struct ICCallGlue {
  186.         PPC_Glue(GlueParms);
  187.     };
  188.     
  189.     typedef struct ICCallGlue ICCallGlue;
  190. #pragma options align=reset
  191.     
  192.     ICCallGlue glue;
  193.     
  194.     SetupGlue(glue,kICCBegin,GlueParms,inst);
  195.     
  196.     SetGlueParm(glue,perm,perm);
  197.     SetGlueParm(glue,filler0,0);
  198.     
  199.     return CallComponentGlue(&glue);
  200. }
  201.  
  202. /*
  203.     
  204.     PPC glue to call the component with the correct selector.
  205. */
  206. pascal ICError ICCGetPref(internetConfigurationComponent inst,StringPtr key, ICAttr *attr, Ptr buf, long *size){
  207. #pragma options align=mac68k
  208.     struct GlueParms {
  209.         long* size;
  210.         Ptr buf;
  211.         ICAttr* attr;
  212.         StringPtr key;
  213.     };
  214.     
  215.     typedef struct GlueParms GlueParms;
  216.     
  217.     struct ICCallGlue {
  218.         PPC_Glue(GlueParms);
  219.     };
  220.     
  221.     typedef struct ICCallGlue ICCallGlue;
  222. #pragma options align=reset
  223.     
  224.     ICCallGlue glue;
  225.     
  226.     SetupGlue(glue,kICCGetPref,GlueParms,inst);
  227.     
  228.     SetGlueParm(glue,size,size);
  229.     SetGlueParm(glue,buf,buf);
  230.     SetGlueParm(glue,attr,attr);
  231.     SetGlueParm(glue,key,key);
  232.     
  233.     return CallComponentGlue(&glue);
  234. }
  235.  
  236. /*
  237.     
  238.     PPC glue to call the component with the correct selector.
  239. */
  240. pascal ICError ICCSetPref(internetConfigurationComponent inst,StringPtr key, ICAttr attr, Ptr buf, long size){
  241. #pragma options align=mac68k
  242.     struct GlueParms {
  243.         long size;
  244.         Ptr buf;
  245.         ICAttr attr;
  246.         StringPtr key;
  247.     };
  248.     
  249.     typedef struct GlueParms GlueParms;
  250.     
  251.     struct ICCallGlue {
  252.         PPC_Glue(GlueParms);
  253.     };
  254.     
  255.     typedef struct ICCallGlue ICCallGlue;
  256. #pragma options align=reset
  257.     
  258.     ICCallGlue glue;
  259.     
  260.     SetupGlue(glue,kICCSetPref,GlueParms,inst);
  261.     
  262.     SetGlueParm(glue,size,size);
  263.     SetGlueParm(glue,buf,buf);
  264.     SetGlueParm(glue,attr,attr);
  265.     SetGlueParm(glue,key,key);
  266.     
  267.     return CallComponentGlue(&glue);
  268. }
  269.  
  270. /*
  271.     
  272.     PPC glue to call the component with the correct selector.
  273. */
  274. pascal ICError ICCFindPrefHandle(internetConfigurationComponent inst,StringPtr key, ICAttr *attr, Handle prefh){
  275. #pragma options align=mac68k
  276.     struct GlueParms {
  277.         Handle prefh;
  278.         ICAttr* attr;
  279.         StringPtr key;
  280.     };
  281.     
  282.     typedef struct GlueParms GlueParms;
  283.     
  284.     struct ICCallGlue {
  285.         PPC_Glue(GlueParms);
  286.     };
  287.     
  288.     typedef struct ICCallGlue ICCallGlue;
  289. #pragma options align=reset
  290.     
  291.     ICCallGlue glue;
  292.     
  293.     SetupGlue(glue,kICCFindPrefHandle,GlueParms,inst);
  294.     
  295.     SetGlueParm(glue,attr,attr);
  296.     SetGlueParm(glue,prefh,prefh);
  297.     SetGlueParm(glue,key,key);
  298.     
  299.     return CallComponentGlue(&glue);
  300. }
  301.  
  302. /*
  303.     
  304.     PPC glue to call the component with the correct selector.
  305. */
  306. pascal ICError ICCGetPrefHandle(internetConfigurationComponent inst,StringPtr key, ICAttr *attr, Handle *prefh){
  307. #pragma options align=mac68k
  308.     struct GlueParms {
  309.         Handle* prefh;
  310.         ICAttr* attr;
  311.         StringPtr key;
  312.     };
  313.     
  314.     typedef struct GlueParms GlueParms;
  315.     
  316.     struct ICCallGlue {
  317.         PPC_Glue(GlueParms);
  318.     };
  319.     
  320.     typedef struct ICCallGlue ICCallGlue;
  321. #pragma options align=reset
  322.     
  323.     ICCallGlue glue;
  324.     
  325.     SetupGlue(glue,kICCGetPrefHandle,GlueParms,inst);
  326.     
  327.     SetGlueParm(glue,attr,attr);
  328.     SetGlueParm(glue,prefh,prefh);
  329.     SetGlueParm(glue,key,key);
  330.     
  331.     return CallComponentGlue(&glue);
  332. }
  333.  
  334. /*
  335.     
  336.     PPC glue to call the component with the correct selector.
  337. */
  338. pascal ICError ICCSetPrefHandle(internetConfigurationComponent inst,StringPtr key, ICAttr attr, Handle prefh){
  339. #pragma options align=mac68k
  340.     struct GlueParms {
  341.         Handle prefh;
  342.         ICAttr attr;
  343.         StringPtr key;
  344.     };
  345.     
  346.     typedef struct GlueParms GlueParms;
  347.     
  348.     struct ICCallGlue {
  349.         PPC_Glue(GlueParms);
  350.     };
  351.     
  352.     typedef struct ICCallGlue ICCallGlue;
  353. #pragma options align=reset
  354.     
  355.     ICCallGlue glue;
  356.     
  357.     SetupGlue(glue,kICCSetPrefHandle,GlueParms,inst);
  358.     
  359.     SetGlueParm(glue,attr,attr);
  360.     SetGlueParm(glue,prefh,prefh);
  361.     SetGlueParm(glue,key,key);
  362.     
  363.     return CallComponentGlue(&glue);
  364. }
  365.  
  366. /*
  367.     
  368.     PPC glue to call the component with the correct selector.
  369. */
  370. pascal ICError ICCCountPref(internetConfigurationComponent inst, long *count){
  371. #pragma options align=mac68k
  372.     struct GlueParms {
  373.         long* count;
  374.     };
  375.     
  376.     typedef struct GlueParms GlueParms;
  377.     
  378.     struct ICCallGlue {
  379.         PPC_Glue(GlueParms);
  380.     };
  381.     
  382.     typedef struct ICCallGlue ICCallGlue;
  383. #pragma options align=reset
  384.     
  385.     ICCallGlue glue;
  386.     
  387.     SetupGlue(glue,kICCCountPref,GlueParms,inst);
  388.     
  389.     SetGlueParm(glue,count,count);
  390.     
  391.     return CallComponentGlue(&glue);
  392. }
  393.  
  394. /*
  395.     
  396.     PPC glue to call the component with the correct selector.
  397. */
  398. pascal ICError ICCGetIndPref(internetConfigurationComponent inst, long n,StringPtr key){
  399. #pragma options align=mac68k
  400.     struct GlueParms {
  401.         StringPtr key;
  402.         long n;
  403.     };
  404.     
  405.     typedef struct GlueParms GlueParms;
  406.     
  407.     struct ICCallGlue {
  408.         PPC_Glue(GlueParms);
  409.     };
  410.     
  411.     typedef struct ICCallGlue ICCallGlue;
  412. #pragma options align=reset
  413.     
  414.     ICCallGlue glue;
  415.     
  416.     SetupGlue(glue,kICCGetIndPref,GlueParms,inst);
  417.     
  418.     SetGlueParm(glue,key,key);
  419.     SetGlueParm(glue,n,n);
  420.     
  421.     return CallComponentGlue(&glue);
  422. }
  423.  
  424. /*
  425.     
  426.     PPC glue to call the component with the correct selector.
  427. */
  428. pascal ICError ICCDeletePref(internetConfigurationComponent inst,StringPtr key){
  429. #pragma options align=mac68k
  430.     struct GlueParms {
  431.         StringPtr key;
  432.     };
  433.     
  434.     typedef struct GlueParms GlueParms;
  435.     
  436.     struct ICCallGlue {
  437.         PPC_Glue(GlueParms);
  438.     };
  439.     
  440.     typedef struct ICCallGlue ICCallGlue;
  441. #pragma options align=reset
  442.     
  443.     ICCallGlue glue;
  444.     
  445.     SetupGlue(glue,kICCDeletePref,GlueParms,inst);
  446.     
  447.     SetGlueParm(glue,key,key);
  448.     
  449.     return CallComponentGlue(&glue);
  450. }
  451.  
  452. /*
  453.     
  454.     PPC glue to call the component with the correct selector.
  455. */
  456. pascal ICError ICCEnd(internetConfigurationComponent inst){
  457. #pragma options align=mac68k
  458.     struct ICCallGlue {
  459.         PPC_VoidGlue;
  460.     };
  461.     
  462.     typedef struct ICCallGlue ICCallGlue;
  463. #pragma options align=reset
  464.     
  465.     ICCallGlue glue;
  466.     
  467.     SetupVoidGlue(glue,kICCEnd,inst);
  468.     
  469.     return CallComponentGlue(&glue);
  470. }
  471.  
  472. /*
  473.     
  474.     PPC glue to call the component with the correct selector.
  475. */
  476. pascal ICError ICCDefaultFileName(internetConfigurationComponent inst,StringPtr name){
  477. #pragma options align=mac68k
  478.     struct GlueParms {
  479.         StringPtr name;
  480.     };
  481.     
  482.     typedef struct GlueParms GlueParms;
  483.     
  484.     struct ICCallGlue {
  485.         PPC_Glue(GlueParms);
  486.     };
  487.     
  488.     typedef struct ICCallGlue ICCallGlue;
  489. #pragma options align=reset
  490.     
  491.     ICCallGlue glue;
  492.     
  493.     SetupGlue(glue,kICCDefaultFileName,GlueParms,inst);
  494.     
  495.     SetGlueParm(glue,name,name);
  496.     
  497.     return CallComponentGlue(&glue);
  498. }
  499.  
  500. /*
  501.     
  502.     PPC glue to call the component with the correct selector.
  503. */
  504. pascal ICError ICCGetComponentInstance(internetConfigurationComponent inst, Ptr *component_inst){
  505.     *component_inst = (Ptr)inst;
  506.     return (ICError)noErr;
  507. }
  508.  
  509. /*
  510.     
  511.     PPC glue to call the component with the correct selector.
  512. */
  513. pascal ICError ICCEditPreferences(internetConfigurationComponent inst,StringPtr key){
  514. #pragma options align=mac68k
  515.     struct GlueParms {
  516.         StringPtr key;
  517.     };
  518.     
  519.     typedef struct GlueParms GlueParms;
  520.     
  521.     struct ICCallGlue {
  522.         PPC_Glue(GlueParms);
  523.     };
  524.     
  525.     typedef struct ICCallGlue ICCallGlue;
  526. #pragma options align=reset
  527.     
  528.     ICCallGlue glue;
  529.     
  530.     SetupGlue(glue,kICCEditPreferences,GlueParms,inst);
  531.     
  532.     SetGlueParm(glue,key,key);
  533.     
  534.     return CallComponentGlue(&glue);
  535. }
  536.  
  537. /*
  538.     
  539.     PPC glue to call the component with the correct selector.
  540. */
  541. pascal ICError ICCParseURL(internetConfigurationComponent inst,StringPtr hint, Ptr data, long len,
  542.         long *selStart, long *selEnd, Handle url){
  543. #pragma options align=mac68k
  544.     struct GlueParms {
  545.         Handle url;
  546.         long* selEnd;
  547.         long* selStart;
  548.         long len;
  549.         Ptr data;
  550.         StringPtr hint;
  551.     };
  552.     
  553.     typedef struct GlueParms GlueParms;
  554.     
  555.     struct ICCallGlue {
  556.         PPC_Glue(GlueParms);
  557.     };
  558.     
  559.     typedef struct ICCallGlue ICCallGlue;
  560. #pragma options align=reset
  561.     
  562.     ICCallGlue glue;
  563.     
  564.     SetupGlue(glue,kICCParseURL,GlueParms,inst);
  565.     
  566.     SetGlueParm(glue,url,url);
  567.     SetGlueParm(glue,selEnd,selEnd);
  568.     SetGlueParm(glue,selStart,selStart);
  569.     SetGlueParm(glue,len,len);
  570.     SetGlueParm(glue,hint,hint);
  571.     SetGlueParm(glue,data,data);
  572.     
  573.     return CallComponentGlue(&glue);
  574. }
  575.  
  576. /*
  577.     
  578.     PPC glue to call the component with the correct selector.
  579. */
  580. pascal ICError ICCLaunchURL(internetConfigurationComponent inst,StringPtr hint, Ptr data, long len,
  581.     long *selStart, long *selEnd){
  582. #pragma options align=mac68k
  583.     struct GlueParms {
  584.         long* selEnd;
  585.         long* selStart;
  586.         long len;
  587.         Ptr data;
  588.         StringPtr hint;
  589.     };
  590.     
  591.     typedef struct GlueParms GlueParms;
  592.     
  593.     struct ICCallGlue {
  594.         PPC_Glue(GlueParms);
  595.     };
  596.     
  597.     typedef struct ICCallGlue ICCallGlue;
  598. #pragma options align=reset
  599.     
  600.     ICCallGlue glue;
  601.     
  602.     SetupGlue(glue,kICCLaunchURL,GlueParms,inst);
  603.     
  604.     SetGlueParm(glue,selEnd,selEnd);
  605.     SetGlueParm(glue,selStart,selStart);
  606.     SetGlueParm(glue,len,len);
  607.     SetGlueParm(glue,hint,hint);
  608.     SetGlueParm(glue,data,data);
  609.     
  610.     return CallComponentGlue(&glue);
  611. }
  612.  
  613. /*
  614.     
  615.     PPC glue to call the component with the correct selector.
  616. */
  617. pascal ICError ICCMapFilename(internetConfigurationComponent inst,StringPtr filename, ICMapEntry *entry){
  618. #pragma options align=mac68k
  619.     struct GlueParms {
  620.         ICMapEntry* entry;
  621.         StringPtr filename;
  622.     };
  623.     
  624.     typedef struct GlueParms GlueParms;
  625.     
  626.     struct ICCallGlue {
  627.         PPC_Glue(GlueParms);
  628.     };
  629.     
  630.     typedef struct ICCallGlue ICCallGlue;
  631. #pragma options align=reset
  632.     
  633.     ICCallGlue glue;
  634.     
  635.     SetupGlue(glue,kICCMapFilename,GlueParms,inst);
  636.     
  637.     SetGlueParm(glue,entry,entry);
  638.     SetGlueParm(glue,filename,filename);
  639.     
  640.     return CallComponentGlue(&glue);
  641. }
  642.  
  643. /*
  644.     
  645.     PPC glue to call the component with the correct selector.
  646. */
  647. pascal ICError ICCMapTypeCreator(internetConfigurationComponent inst, OSType fType, OSType fCreator,StringPtr filename,
  648.     ICMapEntry *entry){
  649. #pragma options align=mac68k
  650.     struct GlueParms {
  651.         ICMapEntry* entry;
  652.         StringPtr filename;
  653.         OSType fCreator;
  654.         OSType fType;
  655.     };
  656.     
  657.     typedef struct GlueParms GlueParms;
  658.     
  659.     struct ICCallGlue {
  660.         PPC_Glue(GlueParms);
  661.     };
  662.     
  663.     typedef struct ICCallGlue ICCallGlue;
  664. #pragma options align=reset
  665.     
  666.     ICCallGlue glue;
  667.     
  668.     SetupGlue(glue,kICCMapTypeCreator,GlueParms,inst);
  669.     
  670.     SetGlueParm(glue,entry,entry);
  671.     SetGlueParm(glue,fCreator,fCreator);
  672.     SetGlueParm(glue,fType,fType);
  673.     SetGlueParm(glue,filename,filename);
  674.     
  675.     return CallComponentGlue(&glue);
  676. }
  677.  
  678. /*
  679.     
  680.     PPC glue to call the component with the correct selector.
  681. */
  682. pascal ICError ICCMapEntriesFilename(internetConfigurationComponent inst, Handle entries,StringPtr filename, ICMapEntry *entry){
  683. #pragma options align=mac68k
  684.     struct GlueParms {
  685.         ICMapEntry* entry;
  686.         StringPtr filename;
  687.         Handle entries;
  688.     };
  689.     
  690.     typedef struct GlueParms GlueParms;
  691.     
  692.     struct ICCallGlue {
  693.         PPC_Glue(GlueParms);
  694.     };
  695.     
  696.     typedef struct ICCallGlue ICCallGlue;
  697. #pragma options align=reset
  698.     
  699.     ICCallGlue glue;
  700.     
  701.     SetupGlue(glue,kICCMapEntriesFilename,GlueParms,inst);
  702.     
  703.     SetGlueParm(glue,entry,entry);
  704.     SetGlueParm(glue,entries,entries);
  705.     SetGlueParm(glue,filename,filename);
  706.     
  707.     return CallComponentGlue(&glue);
  708. }
  709.  
  710. /*
  711.     
  712.     PPC glue to call the component with the correct selector.
  713. */
  714. pascal ICError ICCMapEntriesTypeCreator(internetConfigurationComponent inst, Handle entries, OSType fType, OSType fCreator,
  715.         StringPtr filename, ICMapEntry *entry){
  716. #pragma options align=mac68k
  717.     struct GlueParms {
  718.         ICMapEntry* entry;
  719.         StringPtr filename;
  720.         OSType fCreator;
  721.         OSType fType;
  722.         Handle entries;
  723.     };
  724.     
  725.     typedef struct GlueParms GlueParms;
  726.     
  727.     struct ICCallGlue {
  728.         PPC_Glue(GlueParms);
  729.     };
  730.     
  731.     typedef struct ICCallGlue ICCallGlue;
  732. #pragma options align=reset
  733.     
  734.     ICCallGlue glue;
  735.     
  736.     SetupGlue(glue,kICCMapEntriesTypeCreator,GlueParms,inst);
  737.     
  738.     SetGlueParm(glue,entry,entry);
  739.     SetGlueParm(glue,fCreator,fCreator);
  740.     SetGlueParm(glue,entries,entries);
  741.     SetGlueParm(glue,fType,fType);
  742.     SetGlueParm(glue,filename,filename);
  743.     
  744.     return CallComponentGlue(&glue);
  745. }
  746.  
  747. /*
  748.     
  749.     PPC glue to call the component with the correct selector.
  750. */
  751. pascal ICError ICCCountMapEntries(internetConfigurationComponent inst, Handle entries, long *count){
  752. #pragma options align=mac68k
  753.     struct GlueParms {
  754.         long* count;
  755.         Handle entries;
  756.     };
  757.     
  758.     typedef struct GlueParms GlueParms;
  759.     
  760.     struct ICCallGlue {
  761.         PPC_Glue(GlueParms);
  762.     };
  763.     
  764.     typedef struct ICCallGlue ICCallGlue;
  765. #pragma options align=reset
  766.     
  767.     ICCallGlue glue;
  768.     
  769.     SetupGlue(glue,kICCCountMapEntries,GlueParms,inst);
  770.     
  771.     SetGlueParm(glue,count,count);
  772.     SetGlueParm(glue,entries,entries);
  773.     
  774.     return CallComponentGlue(&glue);
  775. }
  776.  
  777. /*
  778.     
  779.     PPC glue to call the component with the correct selector.
  780. */
  781. pascal ICError ICCGetIndMapEntry(internetConfigurationComponent inst, Handle entries, long ndx, long *pos, ICMapEntry *entry){
  782. #pragma options align=mac68k
  783.     struct GlueParms {
  784.         ICMapEntry* entry;
  785.         long* pos;
  786.         long ndx;
  787.         Handle entries;
  788.     };
  789.     
  790.     typedef struct GlueParms GlueParms;
  791.     
  792.     struct ICCallGlue {
  793.         PPC_Glue(GlueParms);
  794.     };
  795.     
  796.     typedef struct ICCallGlue ICCallGlue;
  797. #pragma options align=reset
  798.     
  799.     ICCallGlue glue;
  800.     
  801.     SetupGlue(glue,kICCGetIndMapEntry,GlueParms,inst);
  802.     
  803.     SetGlueParm(glue,entry,entry);
  804.     SetGlueParm(glue,pos,pos);
  805.     SetGlueParm(glue,ndx,ndx);
  806.     SetGlueParm(glue,entries,entries);
  807.     
  808.     return CallComponentGlue(&glue);
  809. }
  810.  
  811. /*
  812.     
  813.     PPC glue to call the component with the correct selector.
  814. */
  815. pascal ICError ICCGetMapEntry(internetConfigurationComponent inst, Handle entries, long pos, ICMapEntry *entry){
  816. #pragma options align=mac68k
  817.     struct GlueParms {
  818.         ICMapEntry* entry;
  819.         long pos;
  820.         Handle entries;
  821.     };
  822.     
  823.     typedef struct GlueParms GlueParms;
  824.     
  825.     struct ICCallGlue {
  826.         PPC_Glue(GlueParms);
  827.     };
  828.     
  829.     typedef struct ICCallGlue ICCallGlue;
  830. #pragma options align=reset
  831.     
  832.     ICCallGlue glue;
  833.     
  834.     SetupGlue(glue,kICCGetMapEntry,GlueParms,inst);
  835.     
  836.     SetGlueParm(glue,entry,entry);
  837.     SetGlueParm(glue,pos,pos);
  838.     SetGlueParm(glue,entries,entries);
  839.     
  840.     return CallComponentGlue(&glue);
  841.     
  842. }
  843.  
  844. /*
  845.     
  846.     PPC glue to call the component with the correct selector.
  847. */
  848. pascal ICError ICCSetMapEntry(internetConfigurationComponent inst, Handle entries, long pos, ICMapEntry *entry){
  849. #pragma options align=mac68k
  850.     struct GlueParms {
  851.         ICMapEntry* entry;
  852.         long pos;
  853.         Handle entries;
  854.     };
  855.     
  856.     typedef struct GlueParms GlueParms;
  857.     
  858.     struct ICCallGlue {
  859.         PPC_Glue(GlueParms);
  860.     };
  861.     
  862.     typedef struct ICCallGlue ICCallGlue;
  863. #pragma options align=reset
  864.     
  865.     ICCallGlue glue;
  866.     
  867.     SetupGlue(glue,kICCSetMapEntry,GlueParms,inst);
  868.     
  869.     SetGlueParm(glue,entry,entry);
  870.     SetGlueParm(glue,pos,pos);
  871.     SetGlueParm(glue,entries,entries);
  872.     
  873.     return CallComponentGlue(&glue);
  874. }
  875.  
  876. /*
  877.     
  878.     PPC glue to call the component with the correct selector.
  879. */
  880. pascal ICError ICCDeleteMapEntry(internetConfigurationComponent inst, Handle entries, long pos){
  881. #pragma options align=mac68k
  882.     struct GlueParms {
  883.         long pos;
  884.         Handle entries;
  885.     };
  886.     
  887.     typedef struct GlueParms GlueParms;
  888.     
  889.     struct ICCallGlue {
  890.         PPC_Glue(GlueParms);
  891.     };
  892.     
  893.     typedef struct ICCallGlue ICCallGlue;
  894. #pragma options align=reset
  895.     
  896.     ICCallGlue glue;
  897.     
  898.     SetupGlue(glue,kICCDeleteMapEntry,GlueParms,inst);
  899.     
  900.     SetGlueParm(glue,pos,pos);
  901.     SetGlueParm(glue,entries,entries);
  902.     
  903.     return CallComponentGlue(&glue);
  904. }
  905.  
  906. /*
  907.     
  908.     PPC glue to call the component with the correct selector.
  909. */
  910. pascal ICError ICCAddMapEntry(internetConfigurationComponent inst, Handle entries, ICMapEntry *entry){
  911. #pragma options align=mac68k
  912.     struct GlueParms {
  913.         ICMapEntry* entry;
  914.         Handle entries;
  915.     };
  916.     
  917.     typedef struct GlueParms GlueParms;
  918.     
  919.     struct ICCallGlue {
  920.         PPC_Glue(GlueParms);
  921.     };
  922.     
  923.     typedef struct ICCallGlue ICCallGlue;
  924. #pragma options align=reset
  925.     
  926.     ICCallGlue glue;
  927.     
  928.     SetupGlue(glue,kICCAddMapEntry,GlueParms,inst);
  929.     
  930.     SetGlueParm(glue,entry,entry);
  931.     SetGlueParm(glue,entries,entries);
  932.     
  933.     return CallComponentGlue(&glue);
  934. }
  935.  
  936. #endif /* USESROUTINEDESCRIPTORS */
  937.  
  938.  
  939.  
  940.  
  941.  
  942.  
  943.  
  944.  
  945.  
  946.  
  947.  
  948.  
  949.  
  950.  
  951.  
  952.  
  953.